package com.youlai.system.common.util;

import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Component;

import java.util.*;
import java.util.concurrent.TimeUnit;

@Component
@Slf4j
public class RedisUtils {

    private static StringRedisTemplate stringRedisTemplate;
    private static RedisTemplate<String, Object> redisTemplate;

    @Autowired
    public RedisUtils(StringRedisTemplate stringRedisTemplate, RedisTemplate<String, Object> redisTemplate) {
        RedisUtils.stringRedisTemplate = stringRedisTemplate;
        RedisUtils.redisTemplate = redisTemplate;
    }

    /**
     * 加锁 可重入
     * <p>
     * Lua 脚本 script ( 如果 key 不存在 or 是自己的锁
     * then state(重入次数)自增
     * 返回 1
     * else 返回 0 )
     * 一个请求如果抢到锁了,返回 true
     * 如果没有抢到锁, 等待 100 ms , 进行重试
     *
     * @param lockName    锁名
     * @param lockNameTwo 二级锁名字
     * @param expire      过期时间
     * @return 加锁是否成功
     */
    public static boolean tryLock(String lockName, String lockNameTwo, Integer expire) {
        String script = "if redis.call('exists', KEYS[1]) == 0 " +
                "or redis.call('hexists', KEYS[1], ARGV[1]) == 1 " +
                "then redis.call('hincrby', KEYS[1], ARGV[1], 1) " +
                "redis.call('expire', KEYS[1], ARGV[2]) " +
                "return 1 " +
                "else " +
                "return 0 end";
        Boolean flag = stringRedisTemplate.execute(new DefaultRedisScript<>(script, Boolean.class), Collections.singletonList(lockName), lockNameTwo, expire.toString());
        if (Boolean.FALSE.equals(flag)) {// 说明没有抢到锁
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                return false;
            }
            tryLock(lockName, lockNameTwo, expire);
        }
        return true;
    }

    /**
     * 加锁 不可重入
     * <p>
     * Lua 脚本 script ( 如果 key 不存在 or 是自己的锁
     * then state(重入次数)自增
     * 返回 1
     * else 返回 0 )
     * 一个请求如果抢到锁了,返回 true
     * 如果没有抢到锁, 等待 100 ms , 进行重试
     *
     * @param lockName    锁名
     * @param expire      过期时间 单位:s
     * @return 加锁是否成功
     */
    public static boolean tryLock(String lockName, Integer expire) throws InterruptedException {
        String script = "if redis.call('exists', KEYS[1]) == 0 " +
                "then redis.call('set', KEYS[1], ARGV[1], 'EX', ARGV[2]) " +
                "return 1 " +
                "else " +
                "return 0 end";
        Boolean flag = stringRedisTemplate.execute(new DefaultRedisScript<>(script, Boolean.class), Collections.singletonList(lockName), "lockValue", expire.toString());

        if (Boolean.FALSE.equals(flag)) {// 说明没有抢到锁
            Thread.sleep(100);
            tryLock(lockName, expire);
        }
        return true;
    }


    /**
     * 释放锁
     * Lua script : ( 如果该锁不存在, 返回null
     * 如果存在, 就删除锁,
     * else 返回 0;)
     * 当一个请求过来, 它首先判断 该锁 是不是属于自己的,
     * 如果是: 删除 该锁
     * 如果不是: 异常
     *
     * 不去管这个锁是谁的, 只要有钥匙 ,都能解锁
     * 因为加锁的逻辑是 只要该锁存在, 那就获取不了锁
     * @param lockName    锁名
     */
    public static void unLock(String lockName) {
        String script = "if redis.call('exists', KEYS[1]) == 0 " +
                "then return nil " +
                "else return redis.call('del', KEYS[1]) " +
                "end";
        Long flag = stringRedisTemplate.execute(new DefaultRedisScript<>(script, Long.class), Collections.singletonList(lockName));
        if (flag == null) {
            throw new RuntimeException("你删除的key 不存在");
        }
    }

    /**
     * 释放锁 可重入锁
     * Lua script : ( 如果该锁不存在, 返回null
     * 如果存在,对 state(重入次数) 值进行 减 1
     * 如果 减 1 后 == 0 , 就删除锁,
     * else 返回 0;)
     * 当一个请求过来, 它首先判断 该锁 是不是属于自己的,
     * 如果是: 对该锁的重入次数 - 1 , 如果 - 完之后 == 0 , 删除 该锁
     * 如果不是: 异常
     *
     * @param lockName    锁名
     * @param lockNameTwo 二级锁名字
     */
    public static void unLock(String lockName, String lockNameTwo) {
        String script = "if redis.call('hexists', KEYS[1], ARGV[1]) == 0 " +
                "then return nil " +
                "elseif " +
                "redis.call('hincrby', KEYS[1], ARGV[1], -1) == 0 " +
                "then return redis.call('del', KEYS[1]) " +
                "else " +
                "return 0 " +
                "end";
        Long flag = stringRedisTemplate.execute(new DefaultRedisScript<>(script, Long.class), Collections.singletonList(lockName), lockNameTwo);
        if (flag == null) {
            throw new RuntimeException("你删除的key 不存在");
        }
    }

    /**
     * 刷新缓存
     * @param key 缓存键值
     * @param time 过期时间
     **/
    public static void refreshCache(String key, Long time) {
        if (StringUtils.isNotBlank(key) && null != time && time.longValue() > 0) {
            String obj = get(key);
            if (null != obj) {
                set(key, obj, time);
            }
        }
    }

    /**
     * 判断缓存是否存在
     *
     * @param key 缓存key
     * @return 缓存是否存在
     */
    public static Boolean hasKey(String key) {
        return stringRedisTemplate.hasKey(key);
    }

    /**
     * 该hash中是否存在field
     *
     */
    public static Boolean hasKey(String key, String field) {
        return stringRedisTemplate.opsForHash().hasKey(key, field);
    }

    /**
     * 缓存数据
     *
     * @param key   缓存key
     * @param value 缓存值
     */
    public static void set(String key, String value) {
        stringRedisTemplate.opsForValue().set(key, value);
    }

    public static void set(String key, Object obj) {
        redisTemplate.opsForValue().set(key, obj);
    }


    /**
     * 缓存数据
     *
     * @param key     缓存key
     * @param value   缓存值
     * @param timeout 缓存失效时间，单位：秒
     */
    public static void set(String key, String value, long timeout) {
        set(key, value, timeout, TimeUnit.SECONDS);
    }


    /**
     * 缓存数据
     *
     * @param key     缓存key
     * @param value   缓存值
     * @param timeout 缓存失效时间，单位：秒
     * @param unit    时间单位
     */
    public static void set(String key, String value, Long timeout, TimeUnit unit) {
        stringRedisTemplate.opsForValue().set(key, value, timeout, unit);
    }

    /**
     * 获取缓存
     *
     * @param key 缓存key
     * @return 缓存值
     */
    public static String get(String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }

    /**
     * 获取缓存
     *
     * @param key 缓存key
     * @return 缓存值
     */
    public static Object getObj(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 缓存失效时间设置
     *
     * @param key     缓存key
     * @param timeout 失效时间 ,单位s
     */
    public static void expire(String key, Long timeout) {
        stringRedisTemplate.expire(key, timeout, TimeUnit.SECONDS);
    }

    /**
     * 缓存失效时间设置
     *
     * @param key  缓存key
     * @param date 失效时间
     */
    public static void expireAt(String key, Date date) {
        stringRedisTemplate.expireAt(key, date);
    }

    /**
     * 删除缓存
     *
     * @param key 缓存key
     * @return 是否删除成功
     */
    public static Boolean delete(String key) {
        return stringRedisTemplate.delete(key);
    }

    /**
     * 删除缓存
     *
     * @param key 缓存key
     * @return 是否删除成功
     */
    public static Boolean del(String key) {
        return stringRedisTemplate.delete(key);
    }

    public static Boolean remove(String key) {
        return delete(key);
    }

    /**
     * 删除缓存
     *
     * @param key 缓存key
     * @param field field
     * @return Long
     */
    public static Long remove(String key, String field) {
        return deleteHash(key, field);
    }

    /**
     * 删除缓存
     *
     * @param key 缓存key
     * @param field field
     * @return Long
     */
    public static Long deleteHash(String key, String field) {
        return stringRedisTemplate.opsForHash().delete(key, field);
    }

    public static Long remove(String key, List<String> fieldList) {
        return deleteHash(key, fieldList);
    }

    public static Long deleteHash(String key, List<String> fieldList) {
        return stringRedisTemplate.opsForHash().delete(key, fieldList.toArray());
    }


    public static void deleteKeysWithPrefix(String prefix) {
        Set<String> keys = stringRedisTemplate.keys(prefix);
        if (ObjUtils.isNotEmpty(keys)) {
            stringRedisTemplate.delete(keys);
        }

    }

    /**
     * 往hash中添加字段和值
     *
     * @param key   缓存key
     * @param field hash表中的key
     * @param value hash表中的value
     */
    public static void hashSet(String key, String field, String value) {
        stringRedisTemplate.opsForHash().put(key, field, value);
    }


    /**
     * 删除多个缓存
     *
     * @return 成功删除数量
     */
    public static Long delete(List<String> keys) {
        return stringRedisTemplate.delete(keys);
    }

    /**
     * 删除hash中field缓存
     *
     * @param key    缓存key
     * @param fields hash表的key列表
     * @return 成功删除数量
     */
    public static Long hashDelete(String key, List<String> fields) {
        return stringRedisTemplate.opsForHash().delete(key, fields.toArray());
    }

    /**
     * 删除hash中field缓存
     *
     * @param key    缓存key
     * @param field hash表的key列表
     * @return 成功删除数量
     */
    public static Long hashDelete(String key, Object field) {
        return stringRedisTemplate.opsForHash().delete(key, field);
    }

    /**
     * 计数器加1
     */
    public static Long increment(String key) {
        return stringRedisTemplate.opsForValue().increment(key);
    }

    /**
     * 计数器以指定步长递增
     *
     * @param key   计数器key
     * @param delta 自增步长
     * @return long
     */
    public static Long increment(String key, long delta) {
        return stringRedisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 计数器以指定步长递增
     *
     * @param key   计数器key
     * @param delta 自增步长
     * @return double
     */
    public static Double increment(String key, double delta) {
        return stringRedisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * hash中field对应计数器加值
     */
    public static Long hashIncrement(String key, String field, long delta) {
        return stringRedisTemplate.opsForHash().increment(key, field, delta);
    }

    public static Long hashIncrement(String key, String field) {
        return hashIncrement(key, field, 1);
    }

    /**
     * 计数器减1
     */
    public static Long decrement(String key) {
        return stringRedisTemplate.opsForValue().decrement(key);
    }

    /**
     * 计数器以指定步长递减
     *
     * @param key   计数器key
     * @param delta 递减步长
     */
    public static Long decrement(String key, long delta) {
        return stringRedisTemplate.opsForValue().decrement(key, delta);
    }


    /**
     * 从队列右边移除一个元素并返回该元素
     */
    public static String rightPop(String key) {
        return stringRedisTemplate.opsForList().rightPop(key);
    }

    /**
     * 往列表尾部插入一个元素
     */
    public static void rightPush(String key, String value) {
        stringRedisTemplate.opsForList().rightPush(key, value);
    }

    /**
     * 从队列尾部插入多个元素
     *
     * @param key    键值
     * @param values 插入元素列表
     * @return 插入个数
     */
    public static Long rightPushAll(String key, String... values) {
        return stringRedisTemplate.opsForList().rightPushAll(key, values);
    }

    /**
     * 移除并获取列表头部第一个元素
     */
    public static String leftPop(String key) {
        return stringRedisTemplate.opsForList().leftPop(key);
    }

    /**
     * 从队列左边插入一个元素
     *
     * @param key   键值
     * @param value 插入元素
     * @return 插入个数
     */
    public static Long leftPush(String key, String value) {
        return stringRedisTemplate.opsForList().leftPush(key, value);
    }

    /**
     * 从队列左边插入多个元素
     *
     * @param key    键值
     * @param values 插入元素列表
     * @return 插入个数
     */
    public static Long leftPushAll(String key, String... values) {
        return stringRedisTemplate.opsForList().leftPushAll(key, values);
    }

    /**
     * 获取列表长度
     */
    public static Long listSize(String key) {
        return stringRedisTemplate.opsForList().size(key);
    }

    /**
     * 获取列表中的数据
     *
     * @param key   缓存值
     * @param start list开始下标
     * @param end   list结束下标，-1代表末尾
     */
    public static List<String> listRange(String key, int start, int end) {
        return stringRedisTemplate.opsForList().range(key, start, end);
    }

    /**
     * 保留指定区间内元素，其余元素都将被删除
     *
     * @param key   list key
     * @param start 开始下标
     * @param end   结束下标
     */
    public static void listTrim(String key, int start, int end) {
        stringRedisTemplate.opsForList().trim(key, start, end);
    }

    /**
     * 批量查询
     *
     * @param keys 查询主键列表
     */
    public static List<String> multiGet(List<String> keys) {
        return stringRedisTemplate.opsForValue().multiGet(keys);
    }

    /**
     * 将member元素添加到有序集key中，按score排序
     *
     * @param key    有序集
     * @param member 有续集的成员
     * @param score  有序集的排序值
     * @return 是否添加成功
     */
    public static Boolean zAdd(String key, String member, double score) {
        return stringRedisTemplate.opsForZSet().add(key, member, score);
    }

    /**
     * 批量添加元素到有序集key中
     *
     * @param key    有序集
     * @param tuples 元素列表
     * @return 添加数量
     */
    public static Long zAdd(String key, Set<ZSetOperations.TypedTuple<String>> tuples) {
        return stringRedisTemplate.opsForZSet().add(key, tuples);
    }

    /**
     * 返回有序集 key 中，指定区间内的成员。
     *
     * @param key   有序集
     * @param start 下标起始位置，从0开始
     * @param end   下标结束位置，-1表示最后一个
     * @return 有序集列表
     */
    public static Set<ZSetOperations.TypedTuple<String>> zRange(String key, long start, long end) {
        return stringRedisTemplate.opsForZSet().rangeWithScores(key, start, end);
    }

    /**
     * 根据设置的score获取区间值
     *
     * @param key 有序集
     * @param min score起始值
     * @param max score结束值
     * @return 有序区间值
     */
    public static Set<ZSetOperations.TypedTuple<String>> zRangeByScore(String key, double min, double max) {
        return stringRedisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max);
    }

    /**
     * 根据设置的score获取区间值
     *
     * @param key    有序集
     * @param min    score起始值
     * @param max    score结束值
     * @param offset 偏移值
     * @param count  返回数量
     * @return 有序区间值
     */
    public static Set<ZSetOperations.TypedTuple<String>> zRangeByScore(String key, double min, double max, int offset, int count) {
        return stringRedisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max, offset, count);
    }

    /**
     * 移除有序集 key 中，所有 score 值介于 min 和 max 之间
     *
     * @param key 有序集
     * @param min score最小值
     * @param max score最大值
     * @return 删除条数
     */
    public static Long removeByScore(String key, double min, double max) {
        return stringRedisTemplate.opsForZSet().removeRangeByScore(key, min, max);
    }

    /**
     * 删除zset中的某个元素
     *
     * @param key    有序集
     * @param values 元素
     * @return 删除条数
     */
    public static Long zSetRemove(String key, String... values) {
        return stringRedisTemplate.opsForZSet().remove(key, (Object) values);
    }

    /**
     * 根据score范围查询元素，倒序排序
     *
     * @param key    有序集
     * @param min    score最小值
     * @param max    score最大值
     * @param offset 偏移量
     * @param count  返回数量
     * @return Set<ZSetOperations.TypedTuple < String>>
     */
    public static Set<ZSetOperations.TypedTuple<String>> zReverseRangeByScoreWithScores(String key, double min, double max, long offset, long count) {
        return stringRedisTemplate.opsForZSet().reverseRangeByScoreWithScores(key, min, max, offset, count);
    }

    /**
     * 根据score范围查询元素，倒序排序
     *
     * @param key 有序集
     * @param min score最小值
     * @param max score最大值
     * @return Set<ZSetOperations.TypedTuple < String>>
     */
    public static Set<ZSetOperations.TypedTuple<String>> zReverseRangeByScoreWithScores(String key, double min, double max) {
        return stringRedisTemplate.opsForZSet().reverseRangeByScoreWithScores(key, min, max);
    }

    /**
     * zset根据下标倒序查询
     *
     * @param key   缓存key
     * @param start 开始下标
     * @param end   结束下标
     */
    public static Set<ZSetOperations.TypedTuple<String>> zReverseRangeByScore(String key, long start, long end) {
        return stringRedisTemplate.opsForZSet().reverseRangeWithScores(key, start, end);
    }


    /**
     * 获取元素的分值
     *
     * @param key   有序集
     * @param value 元素
     * @return 分值
     */
    public static Double score(String key, String value) {
        return stringRedisTemplate.opsForZSet().score(key, value);
    }

    /**
     * 指定元素增加score
     *
     * @param key   有序集
     * @param value 元素
     * @param delta 增加值
     * @return score
     */
    public static Double incrementScore(String key, String value, double delta) {
        return stringRedisTemplate.opsForZSet().incrementScore(key, value, delta);
    }

    /**
     * 查询zset大小
     *
     * @param key 有序集
     * @return zset元素数量
     */
    public static Long zSize(String key) {
        return stringRedisTemplate.opsForZSet().size(key);
    }

    /**
     * 根据score范围查询数量
     *
     * @param key 有序集
     * @param min score最小值
     * @param max score最大值
     * @return 统计数量
     */
    public static Long zCount(String key, double min, double max) {
        return stringRedisTemplate.opsForZSet().count(key, min, max);
    }

    /**
     * 根据参数 count 的值，移除列表中与参数 delta 相等的元素。
     *
     * @param key   队列
     * @param count count > 0 : 从表头开始向表尾搜索，移除与 VALUE 相等的元素，数量为 COUNT 。
     *              count < 0 : 从表尾开始向表头搜索，移除与 VALUE 相等的元素，数量为 COUNT 的绝对值。
     *              count = 0 : 移除表中所有与 VALUE 相等的值。
     * @param value 元素
     */
    public static Long listRem(String key, long count, String value) {
        return stringRedisTemplate.opsForList().remove(key, count, value);
    }


    /**
     * 移除有序集中，指定排名(rank)区间内的所有成员。
     *
     * @param key   key
     * @param start 排名开始位置
     * @param end   排名结束位置
     * @return 被移除成员的数量
     */
    public static Long zRemByRank(String key, long start, long end) {
        return stringRedisTemplate.opsForZSet().removeRange(key, start, end);
    }

    /**
     * 返回哈希表中，所有的字段和值
     *
     * @param key key
     * @return 所有的字段和值
     */
    public static Map<Object, Object> hashAll(String key) {
        return stringRedisTemplate.opsForHash().entries(key);
    }

    /**
     * 哈希获取数据
     */
    public static String hashGet(String key, String hashKey) {
        if (ObjUtils.isAnyEmpty(key, hashKey)) return Constants.EMPTY;

        try {
            HashOperations<String, String, String> hash = stringRedisTemplate.opsForHash();
            return hash.get(key, hashKey);
        } catch (Exception e) {
            log.info("PRO RedisUtils.hashGet key:{},hashKey:{},cause:", key, hashKey, e);
        }
        return Constants.EMPTY;
    }

    public static String hashGet(String key, String hashKey, String defaultValue) {
        String result = hashGet(key, hashKey);
        return ObjUtils.isNotEmpty(result) ? result : defaultValue;
    }

    /**
     * 哈希批量获取 hash key下的所有field 以及对应的值
     */
    public static Map<String, String> hashEntries(String key) {
        HashOperations<String, String, String> hashOperations = stringRedisTemplate.opsForHash();
        return hashOperations.entries(key);
    }

    /**
     * 哈希批量获取数据
     */
    public static List<String> hashMultiGet(String key, List<String> hashKey) {
        HashOperations<String, String, String> hash = stringRedisTemplate.opsForHash();
        return hash.multiGet(key, hashKey);
    }

    public static Map<String, String> hashMultiGetFieldsAndValues(String key, List<String> fields) {
        HashOperations<String, String, String> hashOperations = stringRedisTemplate.opsForHash();
        List<String> values = hashOperations.multiGet(key, fields);
        Map<String, String> fieldValuesMap = new HashMap<>();
        for (int i = 0; i < fields.size(); i++) {
            fieldValuesMap.put(fields.get(i), values.get(i));
        }
        return fieldValuesMap;
    }

    /**
     * 哈希设置数据
     */
    public static void hashSet(String key, String hashKey, String hashValue, long expireTime) {
        stringRedisTemplate.opsForHash().put(key, hashKey, hashValue);
        stringRedisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
    }

    /**
     * 写入缓存设置时效时间
     * @param key key
     * @param map map
     * @param expireTime 时间为秒
     * @return boolean
     */
    public static boolean hashSetMap(String key, Map<String, String> map, long expireTime) {
        boolean result = false;
        if (ObjUtils.isEmpty(map)) {
            return false;
        }
        try {
            stringRedisTemplate.opsForHash().putAll(key, map);
            stringRedisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            log.error("PRO RedisUtils.hmSetMap key:{}, map:{}, cause:", key, JSONUtil.toJsonStr(map), e);
        }
        return result;
    }

    /**
     * 写入缓存设置时效时间
     * @param key key
     * @param map map
     * @return boolean
     */
    public static boolean hashSetMap(String key, Map<String, String> map) {
        boolean result = false;
        try {
            stringRedisTemplate.opsForHash().putAll(key, map);
            result = true;
        } catch (Exception e) {
            log.error("PRO RedisUtils.hmSetMap key:{}, map:{}, cause:", key, JSONUtil.toJsonStr(map), e);
        }
        return result;
    }

}